home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / SpeechRecognition.p < prev    next >
Text File  |  1996-05-01  |  21KB  |  441 lines
  1. {
  2.      File:        SpeechRecognition.p
  3.  
  4.      Contains:    Apple Speech Recognition Toolbox Interfaces.
  5.  
  6.      Version:    Technology:    PlainTalk 1.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT SpeechRecognition;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __SPEECHRECOGNITION__}
  28. {$SETC __SPEECHRECOGNITION__ := 1}
  29.  
  30. {$I+}
  31. {$SETC SpeechRecognitionIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __MEMORY__}
  35. {$I Memory.p}
  36. {$ENDC}
  37.  
  38. {$PUSH}
  39. {$ALIGN MAC68K}
  40. {$LibExport+}
  41.  
  42. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  43. {  Error Codes [Speech recognition gets -5100 through -5199]  }
  44.  
  45. CONST
  46.     kSRNotAvailable                = -5100;                        {  the service requested is not avail or applicable  }
  47.     kSRInternalError            = -5101;                        {  a system internal or hardware error condition  }
  48.     kSRComponentNotFound        = -5102;                        {  a needed system resource was not located  }
  49.     kSROutOfMemory                = -5103;                        {  an out of memory error occurred in the toolbox memory space  }
  50.     kSRNotASpeechObject            = -5104;                        {  the object specified is no longer or never was valid  }
  51.     kSRBadParameter                = -5105;                        {  an invalid parameter was specified  }
  52.     kSRParamOutOfRange            = -5106;                        {  when we say 0-100, don't pass in 101.  }
  53.     kSRBadSelector                = -5107;                        {  an unrecognized selector was specified  }
  54.     kSRBufferTooSmall            = -5108;                        {  returned from attribute access functions  }
  55.     kSRNotARecSystem            = -5109;                        {  the object used was not a SRRecognitionSystem  }
  56.     kSRFeedbackNotAvail            = -5110;                        {  there is no feedback window associated with SRRecognizer  }
  57.     kSRCantSetProperty            = -5111;                        {  a non-settable property was specified  }
  58.     kSRCantGetProperty            = -5112;                        {  a non-gettable property was specified  }
  59.     kSRCantSetDuringRecognition    = -5113;                        {  the property can't be set while recognition is in progress -- do before or between utterances.  }
  60.     kSRAlreadyListening            = -5114;                        {  in response to SRStartListening  }
  61.     kSRNotListeningState        = -5115;                        {  in response to SRStopListening  }
  62.     kSRModelMismatch            = -5116;                        {  no acoustical models are avail to match request  }
  63.     kSRNoClientLanguageModel    = -5117;                        {  trying to access a non-specified SRLanguageModel  }
  64.     kSRNoPendingUtterances        = -5118;                        {  nothing to continue search on  }
  65.     kSRRecognitionCanceled        = -5119;                        {  an abort error occurred during search  }
  66.     kSRRecognitionDone            = -5120;                        {  search has finished, but nothing was recognized  }
  67.     kSROtherRecAlreadyModal        = -5121;                        {  another recognizer is modal at the moment, so can't set this recognizer's kSRBlockModally property right now  }
  68.     kSRHasNoSubItems            = -5122;                        {  SRCountItems or related routine was called on an object without subelements -- e.g. a word -- rather than phrase, path, or LM.  }
  69.     kSRSubItemNotFound            = -5123;                        {  returned when accessing a non-existent sub item of a container  }
  70.     kSRLanguageModelTooBig        = -5124;                        {  Cant build language models so big  }
  71.     kSRAlreadyReleased            = -5125;                        {  this object has already been released before  }
  72.     kSRAlreadyFinished            = -5126;                        {  the language model can't be finished twice  }
  73.     kSRWordNotFound                = -5127;                        {  the spelling couldn't be found in lookup(s)  }
  74.     kSRNotFinishedWithRejection    = -5128;                        {  property not found because the LMObj is not finished with rejection  }
  75.     kSRExpansionTooDeep            = -5129;                        {  Language model is left recursive or is embedded too many levels  }
  76.     kSRTooManyElements            = -5130;                        {  Too many elements added to phrase or path or other langauge model object  }
  77.     kSRCantAdd                    = -5131;                        {  Can't add given type of object to the base SRLanguageObject (e.g.in SRAddLanguageObject)     }
  78.     kSRSndInSourceDisconnected    = -5132;                        {  Sound input source is disconnected  }
  79.     kSRCantReadLanguageObject    = -5133;                        {  An error while trying to create new Language object from file or pointer -- possibly bad format  }
  80.                                                                 {  non-release debugging error codes are included here  }
  81.     kSRNotImplementedYet        = -5199;                        {  you'd better wait for this feature in a future release  }
  82.  
  83. {  Type Definitions  }
  84.  
  85. TYPE
  86.     SRSpeechObject = ^LONGINT;
  87.     SRRecognitionSystem                    = SRSpeechObject;
  88.     SRRecognizer                        = SRSpeechObject;
  89.     SRSpeechSource                        = SRSpeechObject;
  90.     SRRecognitionResult                    = SRSpeechSource;
  91.     SRLanguageObject                    = SRSpeechObject;
  92.     SRLanguageModel                        = SRLanguageObject;
  93.     SRPath                                = SRLanguageObject;
  94.     SRPhrase                            = SRLanguageObject;
  95.     SRWord                                = SRLanguageObject;
  96. {  between 0 and 100  }
  97.     SRSpeedSetting                        = INTEGER;
  98. {  between 0 and 100  }
  99.     SRRejectionLevel                    = INTEGER;
  100. {  When an event occurs, the user supplied proc will be called with a pointer     }
  101. {     to the param passed in and a flag to indicate conditions such                 }
  102. {     as interrupt time or system background time.                                 }
  103.     SRCallBackStructPtr = ^SRCallBackStruct;
  104.     SRCallBackStruct = RECORD
  105.         what:                    LONGINT;                                {  one of notification flags  }
  106.         message:                LONGINT;                                {  contains SRRecognitionResult id  }
  107.         instance:                SRRecognizer;                            {  ID of recognizer being notified  }
  108.         status:                    OSErr;                                    {  result status of last search  }
  109.         flags:                    INTEGER;                                {  non-zero if occurs during interrupt  }
  110.         refCon:                    LONGINT;                                {  user defined - set from SRCallBackParam  }
  111.     END;
  112.  
  113. {  Call back procedure definition  }
  114.     SRCallBackProcPtr = ProcPtr;  { PROCEDURE SRCallBack(VAR param: SRCallBackStruct); }
  115.  
  116.     SRCallBackUPP = UniversalProcPtr;
  117.  
  118. CONST
  119.     uppSRCallBackProcInfo = $000000C0;
  120.  
  121. FUNCTION NewSRCallBackProc(userRoutine: SRCallBackProcPtr): SRCallBackUPP;
  122.     {$IFC NOT GENERATINGCFM }
  123.     INLINE $2E9F;
  124.     {$ENDC}
  125.  
  126. PROCEDURE CallSRCallBackProc(VAR param: SRCallBackStruct; userRoutine: SRCallBackUPP);
  127.     {$IFC NOT GENERATINGCFM}
  128.     INLINE $205F, $4E90;
  129.     {$ENDC}
  130.  
  131. TYPE
  132.     SRCallBackParamPtr = ^SRCallBackParam;
  133.     SRCallBackParam = RECORD
  134.         callBack:                SRCallBackUPP;
  135.         refCon:                    LONGINT;
  136.     END;
  137.  
  138. {  Recognition System Types  }
  139.  
  140. CONST
  141.     kSRDefaultRecognitionSystemID = 0;
  142.  
  143. {  Recognition System Properties  }
  144.     kSRFeedbackAndListeningModes = 'fbwn';                        {  short: one of kSRNoFeedbackHasListenModes, kSRHasFeedbackHasListenModes, kSRNoFeedbackNoListenModes  }
  145.     kSRRejectedWord                = 'rejq';                        {  the SRWord used to represent a rejection  }
  146.     kSRCleanupOnClientExit        = 'clup';                        {  Boolean: Default is true. The rec system and everything it owns is disposed when the client application quits  }
  147.  
  148.     kSRNoFeedbackNoListenModes    = 0;                            {  next allocated recognizer has no feedback window and doesn't use listening modes     }
  149.     kSRHasFeedbackHasListenModes = 1;                            {  next allocated recognizer has feedback window and uses listening modes              }
  150.     kSRNoFeedbackHasListenModes    = 2;                            {  next allocated recognizer has no feedback window but does use listening modes      }
  151.  
  152. {  Speech Source Types  }
  153.     kSRDefaultSpeechSource        = 0;
  154.     kSRLiveDesktopSpeechSource    = 'dklv';                        {  live desktop sound input  }
  155.     kSRCanned22kHzSpeechSource    = 'ca22';                        {  AIFF file based 16 bit, 22.050 KHz sound input  }
  156.  
  157. {  Notification via Apple Event or Callback  }
  158. {  Notification Flags  }
  159.     kSRNotifyRecognitionBeginning = $00000001;                    {  recognition can begin. client must now call SRContinueRecognition or SRCancelRecognition  }
  160.     kSRNotifyRecognitionDone    = $00000002;                    {  recognition has terminated. result (if any) is available.  }
  161.  
  162. {  Apple Event selectors  }
  163. {  AppleEvent message class   }
  164.     kAESpeechSuite                = 'sprc';
  165.  
  166. {  AppleEvent message event ids  }
  167.     kAESpeechDone                = 'srsd';
  168.     kAESpeechDetected            = 'srbd';
  169.  
  170. {  AppleEvent Parameter ids  }
  171.     keySRRecognizer                = 'krec';
  172.     keySRSpeechResult            = 'kspr';
  173.     keySRSpeechStatus            = 'ksst';
  174.  
  175. {  AppleEvent Parameter types  }
  176.     typeSRRecognizer            = 'trec';
  177.     typeSRSpeechResult            = 'tspr';
  178.  
  179. {  SRRecognizer Properties  }
  180.     kSRNotificationParam        = 'noti';                        {  see notification flags below  }
  181.     kSRCallBackParam            = 'call';                        {  type SRCallBackParam  }
  182.     kSRSearchStatusParam        = 'stat';                        {  see status flags below  }
  183.     kSRAutoFinishingParam        = 'afin';                        {  automatic finishing applied on LM for search  }
  184.     kSRForegroundOnly            = 'fgon';                        {  Boolean. Default is true. If true, client recognizer only active when in foreground.     }
  185.     kSRBlockBackground            = 'blbg';                        {  Boolean. Default is false. If true, when client recognizer in foreground, rest of LMs are inactive.     }
  186.     kSRBlockModally                = 'blmd';                        {  Boolean. Default is false. When true, this client's LM is only active LM; all other LMs are inactive. Be nice, don't be modal for long periods!  }
  187.     kSRWantsResultTextDrawn        = 'txfb';                        {  Boolean. Default is true. If true, search results are posted to Feedback window  }
  188.     kSRWantsAutoFBGestures        = 'dfbr';                        {  Boolean. Default is true. If true, client needn't call SRProcessBegin/End to get default feedback behavior  }
  189.     kSRSoundInVolume            = 'volu';                        {  short in [0..100] log scaled sound input power. Can't set this property  }
  190.     kSRReadAudioFSSpec            = 'aurd';                        {  *FSSpec. Specify FSSpec where raw audio is to be read (AIFF format) using kSRCanned22kHzSpeechSource. Reads until EOF  }
  191.     kSRCancelOnSoundOut            = 'caso';                        {  Boolean: Default is true.  If any sound is played out during utterance, recognition is aborted.  }
  192.     kSRSpeedVsAccuracyParam        = 'sped';                        {  SRSpeedSetting between 0 and 100  }
  193.  
  194. {  0 means more accurate but slower.  }
  195. {  100 means (much) less accurate but faster.  }
  196.     kSRUseToggleListen            = 0;                            {  listen key modes  }
  197.     kSRUsePushToTalk            = 1;
  198.  
  199.     kSRListenKeyMode            = 'lkmd';                        {  short: either kSRUseToggleListen or kSRUsePushToTalk  }
  200.     kSRListenKeyCombo            = 'lkey';                        {  short: Push-To-Talk key combination; high byte is high byte of event->modifiers, the low byte is the keycode from event->message  }
  201.     kSRListenKeyName            = 'lnam';                        {  Str63: string representing ListenKeyCombo  }
  202.     kSRKeyWord                    = 'kwrd';                        {  Str255: keyword preceding spoken commands in kSRUseToggleListen mode  }
  203.     kSRKeyExpected                = 'kexp';                        {  Boolean: Must the PTT key be depressed or the key word spoken before recognition can occur?  }
  204.  
  205. {  Operational Status Flags  }
  206.     kSRIdleRecognizer            = $00000001;                    {  engine is not active  }
  207.     kSRSearchInProgress            = $00000002;                    {  search is in progress  }
  208.     kSRSearchWaitForAllClients    = $00000004;                    {  search is suspended waiting on all clients' input  }
  209.     kSRMustCancelSearch            = $00000008;                    {  something has occurred (sound played, non-speech detected) requiring the search to abort  }
  210.     kSRPendingSearch            = $00000010;                    {  we're about to start searching  }
  211.  
  212. {  Recognition Result Properties  }
  213.     kSRTEXTFormat                = 'TEXT';                        {  raw text in user supplied memory  }
  214.     kSRPhraseFormat                = 'lmph';                        {  SRPhrase containing result words  }
  215.     kSRPathFormat                = 'lmpt';                        {  SRPath containing result phrases or words  }
  216.     kSRLanguageModelFormat        = 'lmfm';                        {  top level SRLanguageModel for post parse  }
  217.  
  218. {  SRLanguageObject Family Properties  }
  219.     kSRSpelling                    = 'spel';                        {  spelling of a SRWord or SRPhrase or SRPath, or name of a SRLanguageModel  }
  220.     kSRLMObjType                = 'lmtp';                        {  Returns one of SRLanguageObject Types listed below  }
  221.     kSRRefCon                    = 'refc';                        {  4 bytes of user storage  }
  222.     kSROptional                    = 'optl';                        {  Boolean -- true if SRLanguageObject is optional     }
  223.     kSREnabled                    = 'enbl';                        {  Boolean -- true if SRLanguageObject enabled  }
  224.     kSRRepeatable                = 'rptb';                        {  Boolean -- true if SRLanguageObject is repeatable  }
  225.     kSRRejectable                = 'rjbl';                        {  Boolean -- true if SRLanguageObject is rejectable (Recognition System's kSRRejectedWord  }
  226.                                                                 {         object can be returned in place of SRLanguageObject with this property)     }
  227.     kSRRejectionLevel            = 'rjct';                        {  SRRejectionLevel between 0 and 100  }
  228.  
  229. {  LM Object Types -- returned as kSRLMObjType property of language model objects  }
  230.     kSRLanguageModelType        = 'lmob';                        {  SRLanguageModel  }
  231.     kSRPathType                    = 'path';                        {  SRPath  }
  232.     kSRPhraseType                = 'phra';                        {  SRPhrase  }
  233.     kSRWordType                    = 'word';                        {  SRWord  }
  234.  
  235. {  a normal and reasonable rejection level  }
  236.     kSRDefaultRejectionLevel    = 50;
  237.  
  238. { ****************************************************************************** }
  239. {                         NOTES ON USING THE API                                     }
  240. {                                                                                  }
  241. {         All operations (with the exception of SRGetRecognitionSystem) are         }
  242. {         directed toward an object allocated or begot from New, Get and Read         }
  243. {         type calls.                                                                 }
  244. {                                                                                  }
  245. {         There is a simple rule in dealing with allocation and disposal:             }
  246. {                                                                                  }
  247. {         *    all toolbox allocations are obtained from a SRRecognitionSystem         }
  248. {                                                                                  }
  249. {         *    if you obtain an object via New or Get, then you own a reference      }
  250. {             to that object and it must be released via SRReleaseObject when         }
  251. {             you no longer need it                                                 }
  252. {                                                                                  }
  253. {         *    when you receive a SRRecognitionResult object via AppleEvent or         }
  254. {             callback, it has essentially been created on your behalf and so         }
  255. {             you are responsible for releasing it as above                         }
  256. {                                                                                  }
  257. {         *    when you close a SRRecognitionSystem, all remaining objects which         }
  258. {             were allocated with it will be forcefully released and any             }
  259. {             remaining references to those objects will be invalid.                 }
  260. {                                                                                  }
  261. {         This translates into a very simple guideline:                             }
  262. {             If you allocate it or have it allocated for you, you must release     }
  263. {             it.  If you are only peeking at it, then don't release it.             }
  264. {                                                                                  }
  265. { ****************************************************************************** }
  266. {  Opening and Closing of the SRRecognitionSystem  }
  267. FUNCTION SROpenRecognitionSystem(VAR system: SRRecognitionSystem; systemID: OSType): OSErr;
  268.     {$IFC NOT GENERATINGCFM}
  269.     INLINE $303C, $0400, $AA56;
  270.     {$ENDC}
  271. FUNCTION SRCloseRecognitionSystem(system: SRRecognitionSystem): OSErr;
  272.     {$IFC NOT GENERATINGCFM}
  273.     INLINE $303C, $0201, $AA56;
  274.     {$ENDC}
  275. {  Accessing Properties of any Speech Object  }
  276. FUNCTION SRSetProperty(srObject: SRSpeechObject; selector: OSType; property: UNIV Ptr; propertyLen: Size): OSErr;
  277.     {$IFC NOT GENERATINGCFM}
  278.     INLINE $303C, $0802, $AA56;
  279.     {$ENDC}
  280. FUNCTION SRGetProperty(srObject: SRSpeechObject; selector: OSType; property: UNIV Ptr; VAR propertyLen: Size): OSErr;
  281.     {$IFC NOT GENERATINGCFM}
  282.     INLINE $303C, $0803, $AA56;
  283.     {$ENDC}
  284. {  Any object obtained via New or Get type calls must be released  }
  285. FUNCTION SRReleaseObject(srObject: SRSpeechObject): OSErr;
  286.     {$IFC NOT GENERATINGCFM}
  287.     INLINE $303C, $0204, $AA56;
  288.     {$ENDC}
  289. FUNCTION SRGetReference(srObject: SRSpeechObject; VAR newObjectRef: SRSpeechObject): OSErr;
  290.     {$IFC NOT GENERATINGCFM}
  291.     INLINE $303C, $0425, $AA56;
  292.     {$ENDC}
  293. {  SRRecognizer Instance Functions  }
  294. FUNCTION SRNewRecognizer(system: SRRecognitionSystem; VAR recognizer: SRRecognizer; sourceID: OSType): OSErr;
  295.     {$IFC NOT GENERATINGCFM}
  296.     INLINE $303C, $060A, $AA56;
  297.     {$ENDC}
  298. FUNCTION SRStartListening(recognizer: SRRecognizer): OSErr;
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $303C, $020C, $AA56;
  301.     {$ENDC}
  302. FUNCTION SRStopListening(recognizer: SRRecognizer): OSErr;
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $303C, $020D, $AA56;
  305.     {$ENDC}
  306. FUNCTION SRSetLanguageModel(recognizer: SRRecognizer; languageModel: SRLanguageModel): OSErr;
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $303C, $040E, $AA56;
  309.     {$ENDC}
  310. FUNCTION SRGetLanguageModel(recognizer: SRRecognizer; VAR languageModel: SRLanguageModel): OSErr;
  311.     {$IFC NOT GENERATINGCFM}
  312.     INLINE $303C, $040F, $AA56;
  313.     {$ENDC}
  314. FUNCTION SRContinueRecognition(recognizer: SRRecognizer): OSErr;
  315.     {$IFC NOT GENERATINGCFM}
  316.     INLINE $303C, $0210, $AA56;
  317.     {$ENDC}
  318. FUNCTION SRCancelRecognition(recognizer: SRRecognizer): OSErr;
  319.     {$IFC NOT GENERATINGCFM}
  320.     INLINE $303C, $0211, $AA56;
  321.     {$ENDC}
  322. FUNCTION SRIdle: OSErr;
  323.     {$IFC NOT GENERATINGCFM}
  324.     INLINE $303C, $0028, $AA56;
  325.     {$ENDC}
  326. {  Language Model Building and Manipulation Functions  }
  327. FUNCTION SRNewLanguageModel(system: SRRecognitionSystem; VAR model: SRLanguageModel; name: UNIV Ptr; nameLength: Size): OSErr;
  328.     {$IFC NOT GENERATINGCFM}
  329.     INLINE $303C, $0812, $AA56;
  330.     {$ENDC}
  331. FUNCTION SRNewPath(system: SRRecognitionSystem; VAR path: SRPath): OSErr;
  332.     {$IFC NOT GENERATINGCFM}
  333.     INLINE $303C, $0413, $AA56;
  334.     {$ENDC}
  335. FUNCTION SRNewPhrase(system: SRRecognitionSystem; VAR phrase: SRPhrase; text: UNIV Ptr; textLength: Size): OSErr;
  336.     {$IFC NOT GENERATINGCFM}
  337.     INLINE $303C, $0814, $AA56;
  338.     {$ENDC}
  339. FUNCTION SRNewWord(system: SRRecognitionSystem; VAR word: SRWord; text: UNIV Ptr; textLength: Size): OSErr;
  340.     {$IFC NOT GENERATINGCFM}
  341.     INLINE $303C, $0815, $AA56;
  342.     {$ENDC}
  343. {  Operations on any object of the SRLanguageObject family  }
  344. FUNCTION SRPutLanguageObjectIntoHandle(languageObject: SRLanguageObject; lobjHandle: Handle): OSErr;
  345.     {$IFC NOT GENERATINGCFM}
  346.     INLINE $303C, $0416, $AA56;
  347.     {$ENDC}
  348. FUNCTION SRPutLanguageObjectIntoDataFile(languageObject: SRLanguageObject; fRefNum: INTEGER): OSErr;
  349.     {$IFC NOT GENERATINGCFM}
  350.     INLINE $303C, $0328, $AA56;
  351.     {$ENDC}
  352. FUNCTION SRNewLanguageObjectFromHandle(system: SRRecognitionSystem; VAR languageObject: SRLanguageObject; lObjHandle: Handle): OSErr;
  353.     {$IFC NOT GENERATINGCFM}
  354.     INLINE $303C, $0417, $AA56;
  355.     {$ENDC}
  356. FUNCTION SRNewLanguageObjectFromDataFile(system: SRRecognitionSystem; VAR languageObject: SRLanguageObject; fRefNum: INTEGER): OSErr;
  357.     {$IFC NOT GENERATINGCFM}
  358.     INLINE $303C, $0427, $AA56;
  359.     {$ENDC}
  360. FUNCTION SREmptyLanguageObject(languageObject: SRLanguageObject): OSErr;
  361.     {$IFC NOT GENERATINGCFM}
  362.     INLINE $303C, $0218, $AA56;
  363.     {$ENDC}
  364. FUNCTION SRChangeLanguageObject(languageObject: SRLanguageObject; text: UNIV Ptr; textLength: Size): OSErr;
  365.     {$IFC NOT GENERATINGCFM}
  366.     INLINE $303C, $0619, $AA56;
  367.     {$ENDC}
  368. FUNCTION SRAddLanguageObject(base: SRLanguageObject; addon: SRLanguageObject): OSErr;
  369.     {$IFC NOT GENERATINGCFM}
  370.     INLINE $303C, $041A, $AA56;
  371.     {$ENDC}
  372. FUNCTION SRAddText(base: SRLanguageObject; text: UNIV Ptr; textLength: Size; refCon: LONGINT): OSErr;
  373.     {$IFC NOT GENERATINGCFM}
  374.     INLINE $303C, $081B, $AA56;
  375.     {$ENDC}
  376. FUNCTION SRRemoveLanguageObject(base: SRLanguageObject; toRemove: SRLanguageObject): OSErr;
  377.     {$IFC NOT GENERATINGCFM}
  378.     INLINE $303C, $041C, $AA56;
  379.     {$ENDC}
  380. {  Traversing SRRecognitionResults or SRLanguageObjects  }
  381. FUNCTION SRCountItems(container: SRSpeechObject; VAR count: LONGINT): OSErr;
  382.     {$IFC NOT GENERATINGCFM}
  383.     INLINE $303C, $0405, $AA56;
  384.     {$ENDC}
  385. FUNCTION SRGetIndexedItem(container: SRSpeechObject; VAR item: SRSpeechObject; index: LONGINT): OSErr;
  386.     {$IFC NOT GENERATINGCFM}
  387.     INLINE $303C, $0606, $AA56;
  388.     {$ENDC}
  389. FUNCTION SRSetIndexedItem(container: SRSpeechObject; item: SRSpeechObject; index: LONGINT): OSErr;
  390.     {$IFC NOT GENERATINGCFM}
  391.     INLINE $303C, $0607, $AA56;
  392.     {$ENDC}
  393. FUNCTION SRRemoveIndexedItem(container: SRSpeechObject; index: LONGINT): OSErr;
  394.     {$IFC NOT GENERATINGCFM}
  395.     INLINE $303C, $0408, $AA56;
  396.     {$ENDC}
  397. {  Utilizing the System Feedback Window  }
  398. FUNCTION SRDrawText(recognizer: SRRecognizer; dispText: UNIV Ptr; dispLength: Size): OSErr;
  399.     {$IFC NOT GENERATINGCFM}
  400.     INLINE $303C, $0621, $AA56;
  401.     {$ENDC}
  402. FUNCTION SRDrawRecognizedText(recognizer: SRRecognizer; dispText: UNIV Ptr; dispLength: Size): OSErr;
  403.     {$IFC NOT GENERATINGCFM}
  404.     INLINE $303C, $0622, $AA56;
  405.     {$ENDC}
  406. FUNCTION SRSpeakText(recognizer: SRRecognizer; speakText: UNIV Ptr; speakLength: Size): OSErr;
  407.     {$IFC NOT GENERATINGCFM}
  408.     INLINE $303C, $0620, $AA56;
  409.     {$ENDC}
  410. FUNCTION SRSpeakAndDrawText(recognizer: SRRecognizer; text: UNIV Ptr; textLength: Size): OSErr;
  411.     {$IFC NOT GENERATINGCFM}
  412.     INLINE $303C, $061F, $AA56;
  413.     {$ENDC}
  414. FUNCTION SRStopSpeech(recognizer: SRRecognizer): OSErr;
  415.     {$IFC NOT GENERATINGCFM}
  416.     INLINE $303C, $0223, $AA56;
  417.     {$ENDC}
  418. FUNCTION SRSpeechBusy(recognizer: SRRecognizer): BOOLEAN;
  419.     {$IFC NOT GENERATINGCFM}
  420.     INLINE $303C, $0224, $AA56;
  421.     {$ENDC}
  422. FUNCTION SRProcessBegin(recognizer: SRRecognizer; failed: BOOLEAN): OSErr;
  423.     {$IFC NOT GENERATINGCFM}
  424.     INLINE $303C, $031D, $AA56;
  425.     {$ENDC}
  426. FUNCTION SRProcessEnd(recognizer: SRRecognizer; failed: BOOLEAN): OSErr;
  427.     {$IFC NOT GENERATINGCFM}
  428.     INLINE $303C, $031E, $AA56;
  429.     {$ENDC}
  430. {$ENDC}
  431. {$ALIGN RESET}
  432. {$POP}
  433.  
  434. {$SETC UsingIncludes := SpeechRecognitionIncludes}
  435.  
  436. {$ENDC} {__SPEECHRECOGNITION__}
  437.  
  438. {$IFC NOT UsingIncludes}
  439.  END.
  440. {$ENDC}
  441.